/*
 * Copyright (C) Lucent Technologies 1997
 * All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby
 * granted, provided that the above copyright notice appear in all
 * copies and that both that the copyright notice and this
 * permission notice and warranty disclaimer appear in supporting
 * documentation, and that the name Lucent Technologies or any of
 * its entities not be used in advertising or publicity pertaining
 * to distribution of the software without specific, written prior
 * permission.
 *
 * LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
 * IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
 * THIS SOFTWARE.
 */

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

#define	DEBUG
#include	<stdio.h>
#include	<ctype.h>
#include	<setjmp.h>
#include	<math.h>
#include	<time.h>
#include	<sys/wait.h>
#include	"awk.h"
#include	"y.tab.h"

#define	tempfree(x)	if (istemp(x)) tfree(x)

static jmp_buf env;
extern	Awkfloat	srand_seed;

static	Cell	*execute(Node *);
static	Cell	*gettemp(void), *copycell(Cell *);
static	FILE	*openfile(int, const char *), *redirect(int, Node *);

Node	*winner = NULL;		/* root of parse tree */
static Cell	*tmps;		/* free temporary cells for execution */

static Cell	truecell	= { OBOOL, BTRUE, NULL, NULL, 1.0, NUM, NULL };
Cell	*True	= &truecell;
static Cell	falsecell	= { OBOOL, BFALSE, NULL, NULL, 0.0, NUM, NULL };
Cell	*False	= &falsecell;
static Cell	breakcell	= { OJUMP, JBREAK, NULL, NULL, 0.0, NUM, NULL };
Cell	*jbreak	= &breakcell;
static Cell	contcell	= { OJUMP, JCONT, NULL, NULL, 0.0, NUM, NULL };
Cell	*jcont	= &contcell;
static Cell	nextcell	= { OJUMP, JNEXT, NULL, NULL, 0.0, NUM, NULL };
Cell	*jnext	= &nextcell;
static Cell	nextfilecell	= { OJUMP, JNEXTFILE, NULL, NULL, 0.0,
				    NUM, NULL };
Cell	*jnextfile	= &nextfilecell;
static Cell	exitcell	= { OJUMP, JEXIT, NULL, NULL, 0.0, NUM, NULL };
Cell	*jexit	= &exitcell;
static Cell	retcell		= { OJUMP, JRET, NULL, NULL, 0.0, NUM, NULL };
Cell	*jret	= &retcell;
static Cell	tempcell	= { OCELL, CTEMP, NULL, "", 0.0,
				    NUM|STR|DONTFREE, NULL };

Node	*curnode = NULL;	/* the node being executed, for debugging */

static	void	tfree(Cell *);
static	void	closeall(void);
static	double	ipow(double, int);
static	void	backsub(char **pb_ptr, char **sptr_ptr);


/*
 * buffer memory management
 *
 * pbuf:    address of pointer to buffer being managed
 * psiz:    address of buffer size variable
 * minlen:  minimum length of buffer needed
 * quantum: buffer size quantum
 * pbptr:   address of movable pointer into buffer, or 0 if none
 * whatrtn: name of the calling routine if failure should cause fatal error
 *
 * return   0 for realloc failure, !=0 for success
 */
int
adjbuf(char **pbuf, size_t *psiz, size_t minlen, size_t quantum, char **pbptr,
    const char *whatrtn)
{
	if (minlen > *psiz) {
		char *tbuf;
		int rminlen = quantum ? minlen % quantum : 0;
		int boff = pbptr ? *pbptr - *pbuf : 0;
		/* round up to next multiple of quantum */
		if (rminlen)
			minlen += quantum - rminlen;
		tbuf = (char *)realloc(*pbuf, minlen);
		dprintf(("adjbuf %s: %d %d (pbuf=%p, tbuf=%p)\n", whatrtn,
		    *psiz, minlen, (void *)*pbuf, (void *)tbuf));
		if (tbuf == NULL) {
			if (whatrtn)
				FATAL("out of memory in %s", whatrtn);
			return (0);
		}
		*pbuf = tbuf;
		*psiz = minlen;
		if (pbptr)
			*pbptr = tbuf + boff;
	}
	return (1);
}

void
run(Node *a)	/* execution of parse tree starts here */
{
	extern void stdinit(void);

	stdinit();
	(void) execute(a);
	closeall();
}

static Cell *
execute(Node *u)	/* execute a node of the parse tree */
{
	Cell *(*proc)(Node **, int);
	Cell *x;
	Node *a;

	if (u == NULL)
		return (True);
	for (a = u; ; a = a->nnext) {
		curnode = a;
		if (isvalue(a)) {
			x = (Cell *) (a->narg[0]);
			if (isfld(x) && !donefld)
				fldbld();
			else if (isrec(x) && !donerec)
				recbld();
			return (x);
		}
		/* probably a Cell* but too risky to print */
		if (notlegal(a->nobj))
			FATAL("illegal statement");
		proc = proctab[a->nobj-FIRSTTOKEN];
		x = (*proc)(a->narg, a->nobj);
		if (isfld(x) && !donefld)
			fldbld();
		else if (isrec(x) && !donerec)
			recbld();
		if (isexpr(a))
			return (x);
		/* a statement, goto next statement */
		if (isjump(x))
			return (x);
		if (a->nnext == NULL)
			return (x);
		tempfree(x);
	}
}

/* execute an awk program */
/* a[0] = BEGIN, a[1] = body, a[2] = END */
/*ARGSUSED*/
Cell *
program(Node **a, int n)
{
	Cell *x;

	if (setjmp(env) != 0)
		goto ex;
	if (a[0]) {		/* BEGIN */
		x = execute(a[0]);
		if (isexit(x))
			return (True);
		if (isjump(x)) {
			FATAL("illegal break, continue, next or nextfile "
			    "from BEGIN");
		}
		tempfree(x);
	}
	if (a[1] || a[2])
		while (getrec(&record, &recsize, 1) > 0) {
			x = execute(a[1]);
			if (isexit(x))
				break;
			tempfree(x);
		}
ex:
	if (setjmp(env) != 0)	/* handles exit within END */
		goto ex1;
	if (a[2]) {		/* END */
		x = execute(a[2]);
		if (isbreak(x) || isnext(x) || iscont(x))
			FATAL("illegal break, continue, next or nextfile "
			    "from END");
		tempfree(x);
	}
ex1:
	return (True);
}

struct Frame {	/* stack frame for awk function calls */
	int nargs;	/* number of arguments in this call */
	Cell *fcncell;	/* pointer to Cell for function */
	Cell **args;	/* pointer to array of arguments after execute */
	Cell *retval;	/* return value */
};

#define	NARGS	50	/* max args in a call */

struct Frame *frame = NULL;	/* base of stack frames; dynamically alloc'd */
int	nframe = 0;		/* number of frames allocated */
struct Frame *fp = NULL;	/* frame pointer. bottom level unused */

/*ARGSUSED*/
Cell *
call(Node **a, int n)	/* function call.  very kludgy and fragile */
{
	static Cell newcopycell =
		{ OCELL, CCOPY, 0, "", 0.0, NUM|STR|DONTFREE, NULL };
	int i, ncall, ndef;
	/* handles potential double freeing when fcn & param share a tempcell */
	int freed = 0;
	Node *x;
	Cell *args[NARGS], *oargs[NARGS];	/* BUG: fixed size arrays */
	Cell *y, *z, *fcn;
	char *s;

	fcn = execute(a[0]);	/* the function itself */
	s = fcn->nval;
	if (!isfcn(fcn))
		FATAL("calling undefined function %s", s);
	if (frame == NULL) {
		fp = frame = (struct Frame *)calloc(nframe += 100,
		    sizeof (struct Frame));
		if (frame == NULL) {
			FATAL("out of space for stack frames calling %s", s);
		}
	}
	for (ncall = 0, x = a[1]; x != NULL; x = x->nnext) /* args in call */
		ncall++;
	ndef = (int)fcn->fval;			/* args in defn */
	dprintf(("calling %s, %d args (%d in defn), fp=%d\n",
	    s, ncall, ndef, fp-frame));
	if (ncall > ndef) {
		WARNING("function %s called with %d args, uses only %d",
		    s, ncall, ndef);
	}
	if (ncall + ndef > NARGS) {
		FATAL("function %s has %d arguments, limit %d",
		    s, ncall+ndef, NARGS);
	}
	for (i = 0, x = a[1]; x != NULL; i++, x = x->nnext) {
		/* get call args */
		dprintf(("evaluate args[%d], fp=%d:\n", i, fp-frame));
		y = execute(x);
		oargs[i] = y;
		dprintf(("args[%d]: %s %f <%s>, t=%o\n",
		    i, NN(y->nval), y->fval,
		    isarr(y) ? "(array)" : NN(y->sval), y->tval));
		if (isfcn(y)) {
			FATAL("can't use function %s as argument in %s",
			    y->nval, s);
		}
		if (isarr(y))
			args[i] = y;	/* arrays by ref */
		else
			args[i] = copycell(y);
		tempfree(y);
	}
	for (; i < ndef; i++) {	/* add null args for ones not provided */
		args[i] = gettemp();
		*args[i] = newcopycell;
	}
	fp++;	/* now ok to up frame */
	if (fp >= frame + nframe) {
		int dfp = fp - frame;	/* old index */
		frame = (struct Frame *)
		    realloc(frame, (nframe += 100) * sizeof (struct Frame));
		if (frame == NULL)
			FATAL("out of space for stack frames in %s", s);
		fp = frame + dfp;
	}
	fp->fcncell = fcn;
	fp->args = args;
	fp->nargs = ndef;	/* number defined with (excess are locals) */
	fp->retval = gettemp();

	dprintf(("start exec of %s, fp=%d\n", s, fp-frame));
	/*LINTED align*/
	y = execute((Node *)(fcn->sval));	/* execute body */
	dprintf(("finished exec of %s, fp=%d\n", s, fp-frame));

	for (i = 0; i < ndef; i++) {
		Cell *t = fp->args[i];
		if (isarr(t)) {
			if (t->csub == CCOPY) {
				if (i >= ncall) {
					freesymtab(t);
					t->csub = CTEMP;
					tempfree(t);
				} else {
					oargs[i]->tval = t->tval;
					oargs[i]->tval &= ~(STR|NUM|DONTFREE);
					oargs[i]->sval = t->sval;
					tempfree(t);
				}
			}
		} else if (t != y) {	/* kludge to prevent freeing twice */
			t->csub = CTEMP;
			tempfree(t);
		} else if (t == y && t->csub == CCOPY) {
			t->csub = CTEMP;
			tempfree(t);
			freed = 1;
		}
	}
	tempfree(fcn);
	if (isexit(y) || isnext(y))
		return (y);
	if (freed == 0) {
		tempfree(y);	/* don't free twice! */
	}
	z = fp->retval;			/* return value */
	dprintf(("%s returns %g |%s| %o\n",
	    s, getfval(z), getsval(z), z->tval));
	fp--;
	return (z);
}

static Cell *
copycell(Cell *x)	/* make a copy of a cell in a temp */
{
	Cell *y;

	/* copy is not constant or field */

	y = gettemp();
	y->tval = x->tval & ~(CON|FLD|REC);
	y->csub = CCOPY;	/* prevents freeing until call is over */
	y->nval = x->nval;	/* BUG? */
	if (isstr(x)) {
		y->sval = tostring(x->sval);
		y->tval &= ~DONTFREE;
	} else
		y->tval |= DONTFREE;
	y->fval = x->fval;
	return (y);
}

/*ARGSUSED*/
Cell *
arg(Node **a, int nnn)	/* nth argument of a function */
{
	int n;

	n = ptoi(a[0]);	/* argument number, counting from 0 */
	dprintf(("arg(%d), fp->nargs=%d\n", n, fp->nargs));
	if (n+1 > fp->nargs) {
		FATAL("argument #%d of function %s was not supplied",
		    n+1, fp->fcncell->nval);
	}
	return (fp->args[n]);
}

Cell *
jump(Node **a, int n)	/* break, continue, next, nextfile, return */
{
	Cell *y;

	switch (n) {
	case EXIT:
		if (a[0] != NULL) {
			y = execute(a[0]);
			errorflag = (int)getfval(y);
			tempfree(y);
		}
		longjmp(env, 1);
		/*NOTREACHED*/
	case RETURN:
		if (a[0] != NULL) {
			y = execute(a[0]);
			if ((y->tval & (STR|NUM)) == (STR|NUM)) {
				(void) setsval(fp->retval, getsval(y));
				fp->retval->fval = getfval(y);
				fp->retval->tval |= NUM;
			} else if (y->tval & STR)
				(void) setsval(fp->retval, getsval(y));
			else if (y->tval & NUM)
				(void) setfval(fp->retval, getfval(y));
			else		/* can't happen */
				FATAL("bad type variable %d", y->tval);
			tempfree(y);
		}
		return (jret);
	case NEXT:
		return (jnext);
	case NEXTFILE:
		nextfile();
		return (jnextfile);
	case BREAK:
		return (jbreak);
	case CONTINUE:
		return (jcont);
	default:	/* can't happen */
		FATAL("illegal jump type %d", n);
	}
	/*NOTREACHED*/
	return (NULL);
}

Cell *
awkgetline(Node **a, int n)	/* get next line from specific input */
{
	/* a[0] is variable, a[1] is operator, a[2] is filename */
	Cell *r, *x;
	FILE *fp;
	char *buf;
	size_t bufsize = recsize;
	int mode;

	if ((buf = (char *)malloc(bufsize)) == NULL)
		FATAL("out of memory in getline");

	(void) fflush(stdout);	/* in case someone is waiting for a prompt */
	r = gettemp();
	if (a[1] != NULL) {		/* getline < file */
		x = execute(a[2]);		/* filename */
		mode = ptoi(a[1]);
		if (mode == '|')	/* input pipe */
			mode = LE;	/* arbitrary flag */
		fp = openfile(mode, getsval(x));
		tempfree(x);
		if (fp == NULL)
			n = -1;
		else
			n = readrec(&buf, &bufsize, fp);
		/*LINTED if*/
		if (n <= 0) {
			;
		} else if (a[0] != NULL) {	/* getline var <file */
			x = execute(a[0]);
			(void) setsval(x, buf);
			tempfree(x);
		} else {			/* getline <file */
			(void) setsval(recloc, buf);
			if (is_number(recloc->sval)) {
				recloc->fval = atof(recloc->sval);
				recloc->tval |= NUM;
			}
		}
	} else {			/* bare getline; use current input */
		if (a[0] == NULL)	/* getline */
			n = getrec(&record, &recsize, 1);
		else {			/* getline var */
			n = getrec(&buf, &bufsize, 0);
			x = execute(a[0]);
			(void) setsval(x, buf);
			tempfree(x);
		}
	}
	(void) setfval(r, (Awkfloat)n);
	free(buf);
	return (r);
}

/*ARGSUSED*/
Cell *
getnf(Node **a, int n)	/* get NF */
{
	if (donefld == 0)
		fldbld();
	return ((Cell *)a[0]);
}

/*ARGSUSED*/
Cell *
array(Node **a, int n)	/* a[0] is symtab, a[1] is list of subscripts */
{
	Cell *x, *y, *z;
	char *s;
	Node *np;
	char *buf;
	size_t bufsz = recsize;
	size_t tlen = 0, len, nsub;

	if ((buf = (char *)malloc(bufsz)) == NULL)
		FATAL("out of memory in array");

	x = execute(a[0]);	/* Cell* for symbol table */
	buf[0] = '\0';
	for (np = a[1]; np != NULL; np = np->nnext) {
		y = execute(np);	/* subscript */
		s = getsval(y);
		len = strlen(s);
		nsub = strlen(getsval(subseploc));
		(void) adjbuf(&buf, &bufsz, tlen + len + nsub + 1,
		    recsize, 0, "array");
		(void) memcpy(&buf[tlen], s, len);
		tlen += len;
		if (np->nnext) {
			(void) memcpy(&buf[tlen], *SUBSEP, nsub);
			tlen += nsub;
		}
		buf[tlen] = '\0';
		tempfree(y);
	}
	if (!isarr(x)) {
		dprintf(("making %s into an array\n", NN(x->nval)));
		if (freeable(x))
			xfree(x->sval);
		x->tval &= ~(STR|NUM|DONTFREE);
		x->tval |= ARR;
		x->sval = (char *)makesymtab(NSYMTAB);
	}
	/*LINTED align*/
	z = setsymtab(buf, "", 0.0, STR|NUM, (Array *)x->sval);
	z->ctype = OCELL;
	z->csub = CVAR;
	tempfree(x);
	free(buf);
	return (z);
}

/*ARGSUSED*/
Cell *
awkdelete(Node **a, int n)	/* a[0] is symtab, a[1] is list of subscripts */
{
	Cell *x, *y;
	Node *np;
	char *s;
	size_t nsub;
	size_t tlen = 0, len;

	x = execute(a[0]);	/* Cell* for symbol table */
	if (x == symtabloc) {
		FATAL("cannot delete SYMTAB or its elements");
	}
	if (!isarr(x)) {
		dprintf(("making %s into an array\n", x->nval));
		if (freeable(x))
			xfree(x->sval);
		x->tval &= ~(STR|NUM|DONTFREE);
		x->tval |= ARR;
		x->sval = (char *)makesymtab(NSYMTAB);
	}
	if (a[1] == NULL) {	/* delete the elements, not the table */
		freesymtab(x);
		x->tval &= ~STR;
		x->tval |= ARR;
		x->sval = (char *)makesymtab(NSYMTAB);
	} else {
		size_t bufsz = recsize;
		char *buf;
		if ((buf = (char *)malloc(bufsz)) == NULL)
			FATAL("out of memory in awkdelete");
		buf[0] = '\0';
		for (np = a[1]; np != NULL; np = np->nnext) {
			y = execute(np);	/* subscript */
			s = getsval(y);
			len = strlen(s);
			nsub = strlen(getsval(subseploc));
			(void) adjbuf(&buf, &bufsz, tlen + len + nsub + 1,
			    recsize, 0, "awkdelete");
			(void) memcpy(&buf[tlen], s, len);
			tlen += len;
			if (np->nnext) {
				(void) memcpy(&buf[tlen], *SUBSEP, nsub);
				tlen += nsub;
			}
			buf[tlen] = '\0';
			tempfree(y);
		}
		freeelem(x, buf);
		free(buf);
	}
	tempfree(x);
	return (True);
}

/*ARGSUSED*/
Cell *
intest(Node **a, int n)	/* a[0] is index (list), a[1] is symtab */
{
	Cell *x, *ap, *k;
	Node *p;
	char *buf;
	char *s;
	size_t bufsz = recsize;
	size_t nsub;
	size_t tlen = 0, len;

	ap = execute(a[1]);	/* array name */
	if (!isarr(ap)) {
		dprintf(("making %s into an array\n", ap->nval));
		if (freeable(ap))
			xfree(ap->sval);
		ap->tval &= ~(STR|NUM|DONTFREE);
		ap->tval |= ARR;
		ap->sval = (char *)makesymtab(NSYMTAB);
	}
	if ((buf = (char *)malloc(bufsz)) == NULL) {
		FATAL("out of memory in intest");
	}
	buf[0] = '\0';
	for (p = a[0]; p != NULL; p = p->nnext) {
		x = execute(p);	/* expr */
		s = getsval(x);
		len = strlen(s);
		nsub = strlen(getsval(subseploc));
		(void) adjbuf(&buf, &bufsz, tlen + len + nsub + 1,
		    recsize, 0, "intest");
		(void) memcpy(&buf[tlen], s, len);
		tlen += len;
		tempfree(x);
		if (p->nnext) {
			(void) memcpy(&buf[tlen], *SUBSEP, nsub);
			tlen += nsub;
		}
		buf[tlen] = '\0';
	}
	/*LINTED align*/
	k = lookup(buf, (Array *)ap->sval);
	tempfree(ap);
	free(buf);
	if (k == NULL)
		return (False);
	else
		return (True);
}


Cell *
matchop(Node **a, int n)	/* ~ and match() */
{
	Cell *x, *y;
	char *s, *t;
	int i;
	fa *pfa;
	int (*mf)(fa *, const char *) = match, mode = 0;

	if (n == MATCHFCN) {
		mf = pmatch;
		mode = 1;
	}
	x = execute(a[1]);	/* a[1] = target text */
	s = getsval(x);
	if (a[0] == NULL)	/* a[1] == 0: already-compiled reg expr */
		i = (*mf)((fa *)a[2], s);
	else {
		y = execute(a[2]);	/* a[2] = regular expr */
		t = getsval(y);
		pfa = makedfa(t, mode);
		i = (*mf)(pfa, s);
		tempfree(y);
	}
	tempfree(x);
	if (n == MATCHFCN) {
		int start = patbeg - s + 1;
		if (patlen < 0)
			start = 0;
		(void) setfval(rstartloc, (Awkfloat)start);
		(void) setfval(rlengthloc, (Awkfloat)patlen);
		x = gettemp();
		x->tval = NUM;
		x->fval = start;
		return (x);
	} else if ((n == MATCH && i == 1) || (n == NOTMATCH && i == 0))
		return (True);
	else
		return (False);
}


Cell *
boolop(Node **a, int n)	/* a[0] || a[1], a[0] && a[1], !a[0] */
{
	Cell *x, *y;
	int i;

	x = execute(a[0]);
	i = istrue(x);
	tempfree(x);
	switch (n) {
	case BOR:
		if (i)
			return (True);
		y = execute(a[1]);
		i = istrue(y);
		tempfree(y);
		return (i ? True : False);
	case AND:
		if (!i)
			return (False);
		y = execute(a[1]);
		i = istrue(y);
		tempfree(y);
		return (i ? True : False);
	case NOT:
		return (i ? False : True);
	default:	/* can't happen */
		FATAL("unknown boolean operator %d", n);
	}
	/*NOTREACHED*/
	return (NULL);
}

Cell *
relop(Node **a, int n)	/* a[0] < a[1], etc. */
{
	int i;
	Cell *x, *y;
	Awkfloat j;

	x = execute(a[0]);
	y = execute(a[1]);
	if (x->tval&NUM && y->tval&NUM) {
		j = x->fval - y->fval;
		i = j < 0 ? -1: (j > 0 ? 1: 0);
	} else {
		i = strcmp(getsval(x), getsval(y));
	}
	tempfree(x);
	tempfree(y);
	switch (n) {
	case LT:	return (i < 0 ? True : False);
	case LE:	return (i <= 0 ? True : False);
	case NE:	return (i != 0 ? True : False);
	case EQ:	return (i == 0 ? True : False);
	case GE:	return (i >= 0 ? True : False);
	case GT:	return (i > 0 ? True : False);
	default:	/* can't happen */
		FATAL("unknown relational operator %d", n);
	}
	/*NOTREACHED*/
	return (False);
}

static void
tfree(Cell *a)	/* free a tempcell */
{
	if (freeable(a)) {
		dprintf(("freeing %s %s %o\n",
		    NN(a->nval), NN(a->sval), a->tval));
		xfree(a->sval);
	}
	if (a == tmps)
		FATAL("tempcell list is curdled");
	a->cnext = tmps;
	tmps = a;
}

static Cell *
gettemp(void)	/* get a tempcell */
{
	int i;
	Cell *x;

	if (!tmps) {
		tmps = (Cell *)calloc(100, sizeof (Cell));
		if (!tmps)
			FATAL("out of space for temporaries");
		for (i = 1; i < 100; i++)
			tmps[i-1].cnext = &tmps[i];
		tmps[i-1].cnext = NULL;
	}
	x = tmps;
	tmps = x->cnext;
	*x = tempcell;
	dprintf(("gtemp %.8s %06lo\n", NN(x->nval), (ulong_t)x));
	return (x);
}

/*ARGSUSED*/
Cell *
indirect(Node **a, int n)	/* $( a[0] ) */
{
	Awkfloat val;
	Cell *x;
	int m;
	char *s;

	x = execute(a[0]);

	/* freebsd: defend against super large field numbers */
	val = getfval(x);
	if ((Awkfloat)INT_MAX < val)
		FATAL("trying to access out of range field %s", x->nval);
	m = (int)val;
	if (m == 0 && !is_number(s = getsval(x)))	/* suspicion! */
		FATAL("illegal field $(%s), name \"%s\"", s, x->nval);
		/* BUG: can x->nval ever be null??? */
	tempfree(x);
	x = fieldadr(m);
	x->ctype = OCELL;	/* BUG?  why are these needed? */
	x->csub = CFLD;
	return (x);
}

/*ARGSUSED*/
Cell *
substr(Node **a, int nnn)		/* substr(a[0], a[1], a[2]) */
{
	int k, m, n;
	char *s;
	int temp;
	Cell *x, *y, *z = NULL;

	x = execute(a[0]);
	y = execute(a[1]);
	if (a[2] != NULL)
		z = execute(a[2]);
	s = getsval(x);
	k = strlen(s) + 1;
	if (k <= 1) {
		tempfree(x);
		tempfree(y);
		if (a[2] != NULL) {
			tempfree(z);
		}
		x = gettemp();
		(void) setsval(x, "");
		return (x);
	}
	m = (int)getfval(y);
	if (m <= 0)
		m = 1;
	else if (m > k)
		m = k;
	tempfree(y);
	if (a[2] != NULL) {
		n = (int)getfval(z);
		tempfree(z);
	} else
		n = k - 1;
	if (n < 0)
		n = 0;
	else if (n > k - m)
		n = k - m;
	dprintf(("substr: m=%d, n=%d, s=%s\n", m, n, s));
	y = gettemp();
	temp = s[n + m - 1];	/* with thanks to John Linderman */
	s[n + m - 1] = '\0';
	(void) setsval(y, s + m - 1);
	s[n + m - 1] = temp;
	tempfree(x);
	return (y);
}

/*ARGSUSED*/
Cell *
sindex(Node **a, int nnn)		/* index(a[0], a[1]) */
{
	Cell *x, *y, *z;
	char *s1, *s2, *p1, *p2, *q;
	Awkfloat v = 0.0;

	x = execute(a[0]);
	s1 = getsval(x);
	y = execute(a[1]);
	s2 = getsval(y);

	z = gettemp();
	for (p1 = s1; *p1 != '\0'; p1++) {
		for (q = p1, p2 = s2; *p2 != '\0' && *q == *p2; q++, p2++)
			;
		if (*p2 == '\0') {
			v = (Awkfloat) (p1 - s1 + 1);	/* origin 1 */
			break;
		}
	}
	tempfree(x);
	tempfree(y);
	(void) setfval(z, v);
	return (z);
}

#define	MAXNUMSIZE	50

/* printf-like conversions */
int
format(char **pbuf, int *pbufsize, const char *s, Node *a)
{
	char *fmt;
	const char *os;
	Cell *x;
	int flag = 0, n, len;
	int fmtwd; /* format width */
	char *buf = *pbuf;
	size_t bufsize = *pbufsize;
	size_t fmtsz = recsize;
	size_t cnt, tcnt, ret;

	os = s;
	cnt = 0;
	if ((fmt = (char *)malloc(fmtsz)) == NULL)
		FATAL("out of memory in format()");
	while (*s) {
		if (*s != '%') {
			expand_buf(&buf, &bufsize, cnt);
			buf[cnt++] = *s++;
			continue;
		}
		if (*(s+1) == '%') {
			expand_buf(&buf, &bufsize, cnt);
			buf[cnt++] = '%';
			s += 2;
			continue;
		}
		/*
		 * have to be real careful in case this is a huge number,
		 * eg, "%100000d".
		 */
		fmtwd = atoi(s+1);
		if (fmtwd < 0)
			fmtwd = -fmtwd;
		for (tcnt = 0; ; s++) {
			expand_buf(&fmt, &fmtsz, tcnt);
			fmt[tcnt++] = *s;
			if (*s == '\0')
				break;
			if (isalpha((uschar)*s) &&
			    *s != 'l' && *s != 'h' && *s != 'L')
				break;	/* the ansi panoply */
			if (*s == '$') {
				FATAL("'$' not permitted in awk formats");
			}
			if (*s == '*') {
				if (a == NULL) {
					FATAL("not enough args in printf(%s) "
					    "or sprintf(%s)", os, os);
				}
				x = execute(a);
				a = a->nnext;
				tcnt--;
				expand_buf(&fmt, &fmtsz, tcnt + 12);
				fmtwd = (int)getfval(x);
				ret = sprintf(&fmt[tcnt], "%d", fmtwd);
				if (fmtwd < 0)
					fmtwd = -fmtwd;
				tcnt += ret;
				tempfree(x);
			}
		}
		fmt[tcnt] = '\0';
		if (fmtwd < 0)
			fmtwd = -fmtwd;

		switch (*s) {
		case 'a': case 'A':
			flag = *s;
			break;
		case 'f': case 'e': case 'g': case 'E': case 'G':
			flag = 'f';
			break;
		case 'd': case 'i':
			flag = 'd';
			if (*(s-1) == 'l')
				break;
			fmt[tcnt - 1] = 'l';
			expand_buf(&fmt, &fmtsz, tcnt);
			fmt[tcnt++] = 'd';
			fmt[tcnt] = '\0';
			break;
		case 'o': case 'x': case 'X': case 'u':
			flag = *(s-1) == 'l' ? 'd' : 'u';
			break;
		case 's':
			flag = 's';
			break;
		case 'c':
			flag = 'c';
			break;
		default:
			WARNING("weird printf conversion %s", fmt);
			flag = '?';
			break;
		}
		if (flag == '?') {
			len = strlen(fmt);
			expand_buf(&buf, &bufsize, cnt + len);
			(void) memcpy(&buf[cnt], fmt, len);
			cnt += len;
			buf[cnt] = '\0';
			continue;
		}
		if (a == NULL) {
			FATAL("not enough args in printf(%s) "
			    "or sprintf(%s)", os, os);
		}
		x = execute(a);
		a = a->nnext;
		n = MAXNUMSIZE;
		if (fmtwd > n)
			n = fmtwd;
retry:
		/* make sure we have at least 1 byte space */
		(void) adjbuf(&buf, &bufsize, 1 + n + cnt,
		    recsize, NULL, "format5");
		len = bufsize - cnt;
		switch (flag) {
		case 'a':
		case 'A':
		case 'f':
			/*LINTED*/
			ret = snprintf(&buf[cnt], len,
			    fmt, getfval(x));
			break;
		case 'd':
			/*LINTED*/
			ret = snprintf(&buf[cnt], len,
			    fmt, (long)getfval(x));
			break;
		case 'u':
			/*LINTED*/
			ret = snprintf(&buf[cnt], len,
			    fmt, (int)getfval(x));
			break;
		case 's':
			/*LINTED*/
			ret = snprintf(&buf[cnt], len,
			    fmt, getsval(x));
			break;
		case 'c':
			if (!isnum(x)) {
				/*LINTED*/
				ret = snprintf(&buf[cnt], len,
				    fmt, getsval(x)[0]);
				break;
			}
			if (getfval(x)) {
				/*LINTED*/
				ret = snprintf(&buf[cnt], len,
				    fmt, (int)getfval(x));
			} else {
				/* explicit null byte */
				buf[cnt] = '\0';
				/* next output will start here */
				buf[cnt + 1] = '\0';
				ret = 1;
			}
			break;
		default:
			FATAL("can't happen: "
			    "bad conversion %c in format()", flag);
		}
		if (ret >= len) {
			(void) adjbuf(&buf, &bufsize, cnt + ret + 1,
			    recsize, NULL, "format6");
			goto retry;
		}
		tempfree(x);
		cnt += ret;
		s++;
	}
	buf[cnt] = '\0';
	free(fmt);
	for (; a != NULL; a = a->nnext)	/* evaluate any remaining args */
		(void) execute(a);
	*pbuf = buf;
	*pbufsize = bufsize;
	return (cnt);
}

/*ARGSUSED*/
Cell *
awksprintf(Node **a, int n)		/* sprintf(a[0]) */
{
	Cell *x;
	Node *y;
	char *buf;
	int bufsz = 3 * recsize;

	if ((buf = (char *)malloc(bufsz)) == NULL)
		FATAL("out of memory in awksprintf");
	y = a[0]->nnext;
	x = execute(a[0]);
	if (format(&buf, &bufsz, getsval(x), y) == -1)
		FATAL("sprintf string %.30s... too long.  can't happen.", buf);
	tempfree(x);
	x = gettemp();
	x->sval = buf;
	x->tval = STR;
	return (x);
}

/*ARGSUSED*/
Cell *
awkprintf(Node **a, int n)		/* printf */
{
	/* a[0] is list of args, starting with format string */
	/* a[1] is redirection operator, a[2] is redirection file */
	FILE *fp;
	Cell *x;
	Node *y;
	char *buf;
	int len;
	int bufsz = 3 * recsize;

	if ((buf = (char *)malloc(bufsz)) == NULL)
		FATAL("out of memory in awkprintf");
	y = a[0]->nnext;
	x = execute(a[0]);
	if ((len = format(&buf, &bufsz, getsval(x), y)) == -1)
		FATAL("printf string %.30s... too long. can't happen.", buf);
	tempfree(x);
	if (a[1] == NULL) {
		(void) fwrite(buf, len, 1, stdout);
		if (ferror(stdout))
			FATAL("write error on stdout");
	} else {
		fp = redirect(ptoi(a[1]), a[2]);
		(void) fwrite(buf, len, 1, fp);
		(void) fflush(fp);
		if (ferror(fp))
			FATAL("write error on %s", filename(fp));
	}
	free(buf);
	return (True);
}

Cell *
arith(Node **a, int n)	/* a[0] + a[1], etc.  also -a[0] */
{
	Awkfloat i, j = 0;
	double v;
	Cell *x, *y, *z;

	x = execute(a[0]);
	i = getfval(x);
	tempfree(x);
	if (n != UMINUS && n != UPLUS) {
		y = execute(a[1]);
		j = getfval(y);
		tempfree(y);
	}
	z = gettemp();
	switch (n) {
	case ADD:
		i += j;
		break;
	case MINUS:
		i -= j;
		break;
	case MULT:
		i *= j;
		break;
	case DIVIDE:
		if (j == 0)
			FATAL("division by zero");
		i /= j;
		break;
	case MOD:
		if (j == 0)
			FATAL("division by zero in mod");
		(void) modf(i/j, &v);
		i = i - j * v;
		break;
	case UMINUS:
		i = -i;
		break;
	case UPLUS: /* handled by getfval(), above */
		break;
	case POWER:
		if (j >= 0 && modf(j, &v) == 0.0) /* pos integer exponent */
			i = ipow(i, (int)j);
		else
			i = errcheck(pow(i, j), "pow");
		break;
	default:	/* can't happen */
		FATAL("illegal arithmetic operator %d", n);
	}
	(void) setfval(z, i);
	return (z);
}

static double
ipow(double x, int n)	/* x**n.  ought to be done by pow, but isn't always */
{
	double v;

	if (n <= 0)
		return (1.0);
	v = ipow(x, n/2);
	if (n % 2 == 0)
		return (v * v);
	else
		return (x * v * v);
}

Cell *
incrdecr(Node **a, int n)		/* a[0]++, etc. */
{
	Cell *x, *z;
	int k;
	Awkfloat xf;

	x = execute(a[0]);
	xf = getfval(x);
	k = (n == PREINCR || n == POSTINCR) ? 1 : -1;
	if (n == PREINCR || n == PREDECR) {
		(void) setfval(x, xf + k);
		return (x);
	}
	z = gettemp();
	(void) setfval(z, xf);
	(void) setfval(x, xf + k);
	tempfree(x);
	return (z);
}

/* a[0] = a[1], a[0] += a[1], etc. */
/* this is subtle; don't muck with it. */
Cell *
assign(Node **a, int n)
{
	Cell *x, *y;
	Awkfloat xf, yf;
	double v;

	y = execute(a[1]);
	x = execute(a[0]);	/* order reversed from before... */
	if (n == ASSIGN) {	/* ordinary assignment */
		/*LINTED if*/
		if (x == y && !(x->tval & (FLD|REC)) && x != nfloc) {
			/*
			 * If this is a self-assignment, we leave things alone,
			 * unless it's a field or NF.
			 */
		} else if ((y->tval & (STR|NUM)) == (STR|NUM)) {
			(void) setsval(x, getsval(y));
			x->fval = getfval(y);
			x->tval |= NUM;
		} else if (isstr(y))
			(void) setsval(x, getsval(y));
		else if (isnum(y))
			(void) setfval(x, getfval(y));
		else
			funnyvar(y, "read value of");
		tempfree(y);
		return (x);
	}
	xf = getfval(x);
	yf = getfval(y);
	switch (n) {
	case ADDEQ:
		xf += yf;
		break;
	case SUBEQ:
		xf -= yf;
		break;
	case MULTEQ:
		xf *= yf;
		break;
	case DIVEQ:
		if (yf == 0)
			FATAL("division by zero in /=");
		xf /= yf;
		break;
	case MODEQ:
		if (yf == 0)
			FATAL("division by zero in %%=");
		(void) modf(xf/yf, &v);
		xf = xf - yf * v;
		break;
	case POWEQ:
		if (yf >= 0 && modf(yf, &v) == 0.0) /* pos integer exponent */
			xf = ipow(xf, (int)yf);
		else
			xf = errcheck(pow(xf, yf), "pow");
		break;
	default:
		FATAL("illegal assignment operator %d", n);
		break;
	}
	tempfree(y);
	(void) setfval(x, xf);
	return (x);
}

/*ARGSUSED*/
Cell *
cat(Node **a, int q)	/* a[0] cat a[1] */
{
	Cell *x, *y, *z;
	int n1, n2;
	char *s = NULL;
	size_t ssz = 0;

	x = execute(a[0]);
	n1 = strlen(getsval(x));
	(void) adjbuf(&s, &ssz, n1 + 1, recsize, 0, "cat1");
	(void) strncpy(s, x->sval, ssz);

	y = execute(a[1]);
	n2 = strlen(getsval(y));
	(void) adjbuf(&s, &ssz, n1 + n2 + 1, recsize, 0, "cat2");
	(void) strncpy(s + n1, y->sval, ssz - n1);

	tempfree(x);
	tempfree(y);

	z = gettemp();
	z->sval = s;
	z->tval = STR;

	return (z);
}

/*ARGSUSED*/
Cell *
pastat(Node **a, int n)	/* a[0] { a[1] } */
{
	Cell *x;

	if (a[0] == NULL)
		x = execute(a[1]);
	else {
		x = execute(a[0]);
		if (istrue(x)) {
			tempfree(x);
			x = execute(a[1]);
		}
	}
	return (x);
}

/*ARGSUSED*/
Cell *
dopa2(Node **a, int n)	/* a[0], a[1] { a[2] } */
{
	Cell	*x;
	int	pair;

	if (!pairstack) {
		/* first time */
		dprintf(("paircnt: %d\n", paircnt));
		pairstack = (int *)calloc(paircnt, sizeof (int));
		if (pairstack == NULL)
			FATAL("out of space in dopa2");
	}

	pair = ptoi(a[3]);
	if (pairstack[pair] == 0) {
		x = execute(a[0]);
		if (istrue(x))
			pairstack[pair] = 1;
		tempfree(x);
	}
	if (pairstack[pair] == 1) {
		x = execute(a[1]);
		if (istrue(x))
			pairstack[pair] = 0;
		tempfree(x);
		x = execute(a[2]);
		return (x);
	}
	return (False);
}

/*ARGSUSED*/
Cell *
split(Node **a, int nnn)	/* split(a[0], a[1], a[2]); a[3] is type */
{
	Cell *x = NULL, *y, *ap;
	char *s, *origs;
	char *fs, *origfs = NULL;
	int sep;
	char *t, temp, num[50];
	int n, tempstat, arg3type;

	y = execute(a[0]);	/* source string */
	origs = s = tostring(getsval(y));
	arg3type = ptoi(a[3]);
	if (a[2] == NULL)	/* fs string */
		fs = getsval(fsloc);
	else if (arg3type == STRING) {	/* split(str,arr,"string") */
		x = execute(a[2]);
		origfs = fs = tostring(getsval(x));
		tempfree(x);
	} else if (arg3type == REGEXPR)
		fs = "(regexpr)";	/* split(str,arr,/regexpr/) */
	else
		FATAL("illegal type of split");
	sep = *fs;
	ap = execute(a[1]);	/* array name */
	freesymtab(ap);
	dprintf(("split: s=|%s|, a=%s, sep=|%s|\n", s, NN(ap->nval), fs));
	ap->tval &= ~STR;
	ap->tval |= ARR;
	ap->sval = (char *)makesymtab(NSYMTAB);

	n = 0;
	if (arg3type == REGEXPR && strlen((char *)((fa*)a[2])->restr) == 0) {
		/*
		 * split(s, a, //); have to arrange things such that it looks
		 * like an empty separator.
		 */
		arg3type = 0;
		fs = "";
		sep = 0;
	}
	if (*s != '\0' && (strlen(fs) > 1 || arg3type == REGEXPR)) {
		/* reg expr */
		fa *pfa;
		if (arg3type == REGEXPR) {	/* it's ready already */
			pfa = (fa *)a[2];
		} else {
			pfa = makedfa(fs, 1);
		}
		if (nematch(pfa, s)) {
			tempstat = pfa->initstat;
			pfa->initstat = 2;
			do {
				n++;
				(void) sprintf(num, "%d", n);
				temp = *patbeg;
				*patbeg = '\0';
				if (is_number(s)) {
					(void) setsymtab(num, s,
					    atof(s),
					    /*LINTED align*/
					    STR|NUM, (Array *)ap->sval);
				} else {
					(void) setsymtab(num, s, 0.0,
					    /*LINTED align*/
					    STR, (Array *)ap->sval);
				}
				*patbeg = temp;
				s = patbeg + patlen;
				if (*(patbeg+patlen-1) == 0 || *s == 0) {
					n++;
					(void) sprintf(num, "%d", n);
					(void) setsymtab(num, "", 0.0,
					    /*LINTED align*/
					    STR, (Array *)ap->sval);
					pfa->initstat = tempstat;
					goto spdone;
				}
			} while (nematch(pfa, s));
			/* bwk: has to be here to reset */
			/* cf gsub and refldbld */
			pfa->initstat = tempstat;
		}
		n++;
		(void) sprintf(num, "%d", n);
		if (is_number(s)) {
			(void) setsymtab(num, s, atof(s),
			    /*LINTED align*/
			    STR|NUM, (Array *)ap->sval);
		} else {
			/*LINTED align*/
			(void) setsymtab(num, s, 0.0, STR, (Array *)ap->sval);
		}
spdone:
		pfa = NULL;
	} else if (sep == ' ') {
		for (n = 0; ; ) {
			while (*s == ' ' || *s == '\t' || *s == '\n')
				s++;
			if (*s == '\0')
				break;
			n++;
			t = s;
			do
				s++;
			while (*s != ' ' && *s != '\t' &&
			    *s != '\n' && *s != '\0')
				;
			temp = *s;
			*s = '\0';
			(void) sprintf(num, "%d", n);
			if (is_number(t)) {
				(void) setsymtab(num, t, atof(t),
				    /*LINTED align*/
				    STR|NUM, (Array *)ap->sval);
			} else {
				(void) setsymtab(num, t, 0.0,
				    /*LINTED align*/
				    STR, (Array *)ap->sval);
			}
			*s = temp;
			if (*s != '\0')
				s++;
		}
	} else if (sep == '\0') {	/* split(s, a, "") => 1 char/elem */
		for (n = 0; *s != 0; s++) {
			char buf[2];
			n++;
			(void) sprintf(num, "%d", n);
			buf[0] = *s;
			buf[1] = '\0';
			if (isdigit((uschar)buf[0])) {
				(void) setsymtab(num, buf, atof(buf),
				    /*LINTED align*/
				    STR|NUM, (Array *)ap->sval);
			} else {
				(void) setsymtab(num, buf, 0.0,
				    /*LINTED align*/
				    STR, (Array *)ap->sval);
			}
		}
	} else if (*s != '\0') {
		for (;;) {
			n++;
			t = s;
			while (*s != sep && *s != '\n' && *s != '\0')
				s++;
			temp = *s;
			*s = '\0';
			(void) sprintf(num, "%d", n);
			if (is_number(t)) {
				(void) setsymtab(num, t, atof(t),
				    /*LINTED align*/
				    STR|NUM, (Array *)ap->sval);
			} else {
				(void) setsymtab(num, t, 0.0,
				    /*LINTED align*/
				    STR, (Array *)ap->sval);
			}
			*s = temp;
			if (*s++ == '\0')
				break;
		}
	}
	tempfree(ap);
	tempfree(y);
	free(origs);
	free(origfs);
	x = gettemp();
	x->tval = NUM;
	x->fval = n;
	return (x);
}

/*ARGSUSED*/
Cell *
condexpr(Node **a, int n)	/* a[0] ? a[1] : a[2] */
{
	Cell *x;

	x = execute(a[0]);
	if (istrue(x)) {
		tempfree(x);
		x = execute(a[1]);
	} else {
		tempfree(x);
		x = execute(a[2]);
	}
	return (x);
}

/*ARGSUSED*/
Cell *
ifstat(Node **a, int n)	/* if (a[0]) a[1]; else a[2] */
{
	Cell *x;

	x = execute(a[0]);
	if (istrue(x)) {
		tempfree(x);
		x = execute(a[1]);
	} else if (a[2] != NULL) {
		tempfree(x);
		x = execute(a[2]);
	}
	return (x);
}

/*ARGSUSED*/
Cell *
whilestat(Node **a, int n)	/* while (a[0]) a[1] */
{
	Cell *x;

	for (;;) {
		x = execute(a[0]);
		if (!istrue(x))
			return (x);
		tempfree(x);
		x = execute(a[1]);
		if (isbreak(x)) {
			x = True;
			return (x);
		}
		if (isnext(x) || isexit(x) || isret(x))
			return (x);
		tempfree(x);
	}
}

/*ARGSUSED*/
Cell *
dostat(Node **a, int n)	/* do a[0]; while(a[1]) */
{
	Cell *x;

	for (;;) {
		x = execute(a[0]);
		if (isbreak(x))
			return (True);
		if (isnext(x) || isexit(x) || isret(x))
			return (x);
		tempfree(x);
		x = execute(a[1]);
		if (!istrue(x))
			return (x);
		tempfree(x);
	}
}

/*ARGSUSED*/
Cell *
forstat(Node **a, int n)	/* for (a[0]; a[1]; a[2]) a[3] */
{
	Cell *x;

	x = execute(a[0]);
	tempfree(x);
	for (;;) {
		if (a[1] != NULL) {
			x = execute(a[1]);
			if (!istrue(x))
				return (x);
			else
				tempfree(x);
		}
		x = execute(a[3]);
		if (isbreak(x))		/* turn off break */
			return (True);
		if (isnext(x) || isexit(x) || isret(x))
			return (x);
		tempfree(x);
		x = execute(a[2]);
		tempfree(x);
	}
}

/*ARGSUSED*/
Cell *
instat(Node **a, int n)	/* for (a[0] in a[1]) a[2] */
{
	Cell *x, *vp, *arrayp, *cp, *ncp;
	Array *tp;
	int i;

	vp = execute(a[0]);
	arrayp = execute(a[1]);
	if (!isarr(arrayp)) {
		dprintf(("making %s into an array\n", arrayp->nval));
		if (freeable(arrayp))
			xfree(arrayp->sval);
		arrayp->tval &= ~(STR|NUM|DONTFREE);
		arrayp->tval |= ARR;
		arrayp->sval = (char *)makesymtab(NSYMTAB);
	}
	/*LINTED align*/
	tp = (Array *)arrayp->sval;
	tempfree(arrayp);
	for (i = 0; i < tp->size; i++) { /* this routine knows too much */
		for (cp = tp->tab[i]; cp != NULL; cp = ncp) {
			(void) setsval(vp, cp->nval);
			ncp = cp->cnext;
			x = execute(a[2]);
			if (isbreak(x)) {
				tempfree(vp);
				return (True);
			}
			if (isnext(x) || isexit(x) || isret(x)) {
				tempfree(vp);
				return (x);
			}
			tempfree(x);
		}
	}
	return (True);
}

/*ARGSUSED*/
Cell *
bltin(Node **a, int n)	/* builtin functions. a[0] is type, a[1] is arg list */
{
	Cell *x, *y;
	Awkfloat u;
	int t;
	Awkfloat tmp;
	char *p, *buf;
	Node *nextarg;
	FILE *fp;
	void flush_all(void);
	int status = 0;

	t = ptoi(a[0]);
	x = execute(a[1]);
	nextarg = a[1]->nnext;
	switch (t) {
	case FLENGTH:
		if (isarr(x)) {
			/* LINTED align */
			u = ((Array *)x->sval)->nelem;
		} else {
			u = strlen(getsval(x));
		}
		break;
	case FLOG:
		u = errcheck(log(getfval(x)), "log"); break;
	case FINT:
		(void) modf(getfval(x), &u); break;
	case FEXP:
		u = errcheck(exp(getfval(x)), "exp"); break;
	case FSQRT:
		u = errcheck(sqrt(getfval(x)), "sqrt"); break;
	case FSIN:
		u = sin(getfval(x)); break;
	case FCOS:
		u = cos(getfval(x)); break;
	case FATAN:
		if (nextarg == NULL) {
			WARNING("atan2 requires two arguments; returning 1.0");
			u = 1.0;
		} else {
			y = execute(a[1]->nnext);
			u = atan2(getfval(x), getfval(y));
			tempfree(y);
			nextarg = nextarg->nnext;
		}
		break;
	case FSYSTEM:
		/* in case something is buffered already */
		(void) fflush(stdout);
		status = system(getsval(x));
		u = status;
		if (status != -1) {
			if (WIFEXITED(status)) {
				u = WEXITSTATUS(status);
			} else if (WIFSIGNALED(status)) {
				u = WTERMSIG(status) + 256;
				if (WCOREDUMP(status))
					u += 256;
			} else	/* something else?!? */
				u = 0;
		}
		break;
	case FRAND:
		/* in principle, rand() returns something in 0..RAND_MAX */
		u = (Awkfloat) (rand() % RAND_MAX) / RAND_MAX;
		break;
	case FSRAND:
		if (isrec(x))	/* no argument provided */
			u = time((time_t *)0);
		else
			u = getfval(x);
		tmp = u;
		srand((unsigned int) u);
		u = srand_seed;
		srand_seed = tmp;
		break;
	case FTOUPPER:
	case FTOLOWER:
		buf = tostring(getsval(x));
		if (t == FTOUPPER) {
			for (p = buf; *p; p++)
				if (islower((uschar)*p))
					*p = toupper((uschar)*p);
		} else {
			for (p = buf; *p; p++)
				if (isupper((uschar)*p))
					*p = tolower((uschar)*p);
		}
		tempfree(x);
		x = gettemp();
		(void) setsval(x, buf);
		free(buf);
		return (x);
	case FFLUSH:
		if (isrec(x) || strlen(getsval(x)) == 0) {
			flush_all();	/* fflush() or fflush("") -> all */
			u = 0;
		} else if ((fp = openfile(FFLUSH, getsval(x))) == NULL)
			u = EOF;
		else
			u = fflush(fp);
		break;
	default:	/* can't happen */
		FATAL("illegal function type %d", t);
		break;
	}
	tempfree(x);
	x = gettemp();
	(void) setfval(x, u);
	if (nextarg != NULL) {
		WARNING("warning: function has too many arguments");
		for (; nextarg != NULL; nextarg = nextarg->nnext)
			(void) execute(nextarg);
	}
	return (x);
}

/*ARGSUSED*/
Cell *
printstat(Node **a, int n)	/* print a[0] */
{
	Node *x;
	Cell *y;
	FILE *fp;

	if (a[1] == NULL)	/* a[1] is redirection operator, a[2] is file */
		fp = stdout;
	else
		fp = redirect(ptoi(a[1]), a[2]);
	for (x = a[0]; x != NULL; x = x->nnext) {
		y = execute(x);
		(void) fputs(getpssval(y), fp);
		tempfree(y);
		if (x->nnext == NULL)
			(void) fputs(getsval(orsloc), fp);
		else
			(void) fputs(getsval(ofsloc), fp);
	}
	if (a[1] != NULL)
		(void) fflush(fp);
	if (ferror(fp))
		FATAL("write error on %s", filename(fp));
	return (True);
}

/*ARGSUSED*/
Cell *
nullproc(Node **a, int n)
{
	return (0);
}


static FILE *
redirect(int a, Node *b)	/* set up all i/o redirections */
{
	FILE *fp;
	Cell *x;
	char *fname;

	x = execute(b);
	fname = getsval(x);
	fp = openfile(a, fname);
	if (fp == NULL)
		FATAL("can't open file %s", fname);
	tempfree(x);
	return (fp);
}

struct files {
	FILE	*fp;
	const char	*fname;
	int	mode;	/* '|', 'a', 'w' => LE/LT, GT */
} *files;

int nfiles;

void
stdinit(void)	/* in case stdin, etc., are not constants */
{
	nfiles = FOPEN_MAX;
	files = calloc(nfiles, sizeof (*files));
	if (files == NULL)
		FATAL("can't allocate file memory for %u files", nfiles);
	files[0].fp = stdin;
	files[0].fname = "/dev/stdin";
	files[0].mode = LT;
	files[1].fp = stdout;
	files[1].fname = "/dev/stdout";
	files[1].mode = GT;
	files[2].fp = stderr;
	files[2].fname = "/dev/stderr";
	files[2].mode = GT;
}

static FILE *
openfile(int a, const char *s)
{
	int i, m;
	FILE *fp = NULL;

	if (*s == '\0')
		FATAL("null file name in print or getline");
	for (i = 0; i < nfiles; i++) {
		if (files[i].fname && strcmp(s, files[i].fname) == 0) {
			if (a == files[i].mode ||
			    (a == APPEND && files[i].mode == GT)) {
				return (files[i].fp);
			}
			if (a == FFLUSH)
				return (files[i].fp);
		}
	}
	if (a == FFLUSH)	/* didn't find it, so don't create it! */
		return (NULL);

	for (i = 0; i < nfiles; i++) {
		if (files[i].fp == 0)
			break;
	}
	if (i >= nfiles) {
		struct files *nf;
		int nnf = nfiles + FOPEN_MAX;
		nf = realloc(files, nnf * sizeof (*nf));
		if (nf == NULL)
			FATAL("cannot grow files for %s and %d files", s, nnf);
		(void) memset(&nf[nfiles], 0, FOPEN_MAX * sizeof (*nf));
		nfiles = nnf;
		files = nf;
	}
	(void) fflush(stdout);	/* force a semblance of order */
	m = a;
	if (a == GT) {
		fp = fopen(s, "wF");
	} else if (a == APPEND) {
		fp = fopen(s, "aF");
		m = GT;	/* so can mix > and >> */
	} else if (a == '|') {	/* output pipe */
		fp = popen(s, "wF");
	} else if (a == LE) {	/* input pipe */
		fp = popen(s, "rF");
	} else if (a == LT) {	/* getline <file */
		fp = strcmp(s, "-") == 0 ?
		    stdin : fopen(s, "rF");	/* "-" is stdin */
	} else	/* can't happen */
		FATAL("illegal redirection %d", a);
	if (fp != NULL) {
		files[i].fname = tostring(s);
		files[i].fp = fp;
		files[i].mode = m;
	}
	return (fp);
}

const char *
filename(FILE *fp)
{
	int i;

	for (i = 0; i < nfiles; i++)
		if (fp == files[i].fp)
			return (files[i].fname);
	return ("???");
}

/*ARGSUSED*/
Cell *
closefile(Node **a, int n)
{
	Cell *x;
	int i, stat;

	x = execute(a[0]);
	(void) getsval(x);
	stat = -1;
	for (i = 0; i < nfiles; i++) {
		if (files[i].fname && strcmp(x->sval, files[i].fname) == 0) {
			if (ferror(files[i].fp)) {
				WARNING("i/o error occurred on %s",
				    files[i].fname);
			}
			if (files[i].mode == '|' || files[i].mode == LE)
				stat = pclose(files[i].fp);
			else
				stat = fclose(files[i].fp);
			if (stat == EOF) {
				WARNING("i/o error occurred closing %s",
				    files[i].fname);
			}
			if (i > 2)	/* don't do /dev/std... */
				xfree(files[i].fname);
			/* watch out for ref thru this */
			files[i].fname = NULL;
			files[i].fp = NULL;
		}
	}
	tempfree(x);
	x = gettemp();
	(void) setfval(x, (Awkfloat) stat);
	return (x);
}

static void
closeall(void)
{
	int i, stat;

	for (i = 0; i < nfiles; i++) {
		if (files[i].fp) {
			if (ferror(files[i].fp)) {
				WARNING("i/o error occurred on %s",
				    files[i].fname);
			}
			if (files[i].mode == '|' || files[i].mode == LE)
				stat = pclose(files[i].fp);
			else
				stat = fclose(files[i].fp);
			if (stat == EOF) {
				WARNING("i/o error occurred while closing %s",
				    files[i].fname);
			}
		}
	}
}

void
flush_all(void)
{
	int i;

	for (i = 0; i < nfiles; i++)
		if (files[i].fp)
			(void) fflush(files[i].fp);
}

/*ARGSUSED*/
Cell *
sub(Node **a, int nnn)	/* substitute command */
{
	char *sptr, *pb, *q;
	Cell *x, *y, *result;
	char *t, *buf;
	fa *pfa;
	size_t bufsz = recsize;

	if ((buf = (char *)malloc(bufsz)) == NULL)
		FATAL("out of memory in sub");
	x = execute(a[3]);	/* target string */
	t = getsval(x);
	if (a[0] == NULL)	/* 0 => a[1] is already-compiled regexpr */
		pfa = (fa *)a[1];	/* regular expression */
	else {
		y = execute(a[1]);
		pfa = makedfa(getsval(y), 1);
		tempfree(y);
	}
	y = execute(a[2]);	/* replacement string */
	result = False;
	if (pmatch(pfa, t)) {
		sptr = t;
		(void) adjbuf(&buf, &bufsz,
		    1 + patbeg - sptr, recsize, 0, "sub");
		pb = buf;
		while (sptr < patbeg)
			*pb++ = *sptr++;
		sptr = getsval(y);
		while (*sptr != '\0') {
			(void) adjbuf(&buf, &bufsz, 5 + pb - buf,
			    recsize, &pb, "sub");
			if (*sptr == '\\') {
				backsub(&pb, &sptr);
			} else if (*sptr == '&') {
				sptr++;
				(void) adjbuf(&buf, &bufsz,
				    1 + patlen + pb - buf, recsize, &pb, "sub");
				for (q = patbeg; q < patbeg+patlen; )
					*pb++ = *q++;
			} else {
				*pb++ = *sptr++;
			}
		}
		*pb = '\0';
		if (pb > buf + bufsz)
			FATAL("sub result1 %.30s too big; can't happen", buf);
		sptr = patbeg + patlen;
		if ((patlen == 0 && *patbeg) || (patlen && *(sptr-1))) {
			(void) adjbuf(&buf, &bufsz,
			    1 + strlen(sptr) + pb - buf, 0, &pb, "sub");
			while ((*pb++ = *sptr++) != '\0')
				;
		}
		if (pb > buf + bufsz)
			FATAL("sub result2 %.30s too big; can't happen", buf);
		(void) setsval(x, buf);	/* BUG: should be able to avoid copy */
		result = True;
	}
	tempfree(x);
	tempfree(y);
	free(buf);
	return (result);
}

/*ARGSUSED*/
Cell *
gsub(Node **a, int nnn)	/* global substitute */
{
	Cell *x, *y;
	char *rptr, *sptr, *t, *pb, *q;
	char *buf;
	fa *pfa;
	int mflag, tempstat, num;
	size_t bufsz = recsize;

	if ((buf = (char *)malloc(bufsz)) == NULL)
		FATAL("out of memory in gsub");
	mflag = 0;	/* if mflag == 0, can replace empty string */
	num = 0;
	x = execute(a[3]);	/* target string */
	t = getsval(x);
	if (a[0] == NULL)	/* 0 => a[1] is already-compiled regexpr */
		pfa = (fa *)a[1];	/* regular expression */
	else {
		y = execute(a[1]);
		pfa = makedfa(getsval(y), 1);
		tempfree(y);
	}
	y = execute(a[2]);	/* replacement string */
	if (pmatch(pfa, t)) {
		tempstat = pfa->initstat;
		pfa->initstat = 2;
		pb = buf;
		rptr = getsval(y);
		do {
			if (patlen == 0 && *patbeg != '\0') {
				/* matched empty string */
				if (mflag == 0) {	/* can replace empty */
					num++;
					sptr = rptr;
					while (*sptr != '\0') {
						(void) adjbuf(&buf, &bufsz,
						    5 + pb - buf, recsize,
						    &pb, "gsub");
						if (*sptr == '\\') {
							backsub(&pb, &sptr);
						} else if (*sptr == '&') {
							sptr++;
							(void) adjbuf(&buf,
							    &bufsz,
							    1+patlen+pb-buf,
							    recsize,
							    &pb, "gsub");
							for (
							    q = patbeg;
							    q < patbeg+patlen;
							    *pb++ = *q++)
								;
						} else {
							*pb++ = *sptr++;
						}
					}
				}
				if (*t == '\0')	/* at end */
					goto done;
				(void) adjbuf(&buf, &bufsz,
				    2 + pb - buf, recsize, &pb, "gsub");
				*pb++ = *t++;
				/* BUG: not sure of this test */
				if (pb > buf + bufsz)
					FATAL("gsub result0 %.30s too big; "
					    "can't happen", buf);
				mflag = 0;
			} else {	/* matched nonempty string */
				num++;
				sptr = t;
				(void) adjbuf(&buf, &bufsz,
				    1 + (patbeg - sptr) + pb - buf,
				    recsize, &pb, "gsub");
				while (sptr < patbeg)
					*pb++ = *sptr++;
				sptr = rptr;
				while (*sptr != '\0') {
					(void) adjbuf(&buf, &bufsz,
					    5 + pb - buf, recsize, &pb, "gsub");
					if (*sptr == '\\') {
						backsub(&pb, &sptr);
					} else if (*sptr == '&') {
						sptr++;
						(void) adjbuf(&buf, &bufsz,
						    1 + patlen + pb - buf,
						    recsize, &pb, "gsub");
						for (
						    q = patbeg;
						    q < patbeg+patlen;
						    *pb++ = *q++)
							;
					} else {
						*pb++ = *sptr++;
					}
				}
				t = patbeg + patlen;
				if (patlen == 0 || *(t-1) == '\0' || *t == '\0')
					goto done;
				if (pb > buf + bufsz)
					FATAL("gsub result1 %.30s too big; "
					    "can't happen", buf);
				mflag = 1;
			}
		} while (pmatch(pfa, t));
		sptr = t;
		(void) adjbuf(&buf, &bufsz,
		    1 + strlen(sptr) + pb - buf, 0, &pb, "gsub");
		while ((*pb++ = *sptr++) != '\0')
			;
	done:
		if (pb < buf + bufsz)
			*pb = '\0';
		else if (*(pb-1) != '\0')
			FATAL("gsub result2 %.30s truncated; "
			    "can't happen", buf);
		/* BUG: should be able to avoid copy + free */
		(void) setsval(x, buf);
		pfa->initstat = tempstat;
	}
	tempfree(x);
	tempfree(y);
	x = gettemp();
	x->tval = NUM;
	x->fval = num;
	free(buf);
	return (x);
}

/*
 * handle \\& variations; sptr[0] == '\\'
 */
static void
backsub(char **pb_ptr, char **sptr_ptr)
{
	char *pb = *pb_ptr, *sptr = *sptr_ptr;

	if (sptr[1] == '\\') {
		if (sptr[2] == '\\' && sptr[3] == '&') { /* \\\& -> \& */
			*pb++ = '\\';
			*pb++ = '&';
			sptr += 4;
		} else if (sptr[2] == '&') {	/* \\& -> \ + matched */
			*pb++ = '\\';
			sptr += 2;
		} else {			/* \\x -> \\x */
			*pb++ = *sptr++;
			*pb++ = *sptr++;
		}
	} else if (sptr[1] == '&') {	/* literal & */
		sptr++;
		*pb++ = *sptr++;
	} else				/* literal \ */
		*pb++ = *sptr++;

	*pb_ptr = pb;
	*sptr_ptr = sptr;
}
